/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.android.threadsample;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentManager.OnBackStackChangedListener;
import android.support.v4.app.FragmentTransaction;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;
import android.view.View;
import android.view.WindowManager;
/**
* This activity displays Picasa's current featured images. It uses a service running
* a background thread to download Picasa's "featured image" RSS feed.
* <p>
* An IntentHandler is used to communicate between the active Fragment and this
* activity. This pattern simulates some of the communication used between
* activities, and allows this activity to make choices of how to manage the
* fragments.
*/
public class DisplayActivity extends FragmentActivity implements OnBackStackChangedListener {
// A handle to the main screen view
View mMainView;
// An instance of the status broadcast receiver
DownloadStateReceiver mDownloadStateReceiver;
// Tracks whether Fragments are displaying side-by-side
boolean mSideBySide;
// Tracks whether navigation should be hidden
boolean mHideNavigation;
// Tracks whether the app is in full-screen mode
boolean mFullScreen;
// Tracks the number of Fragments on the back stack
int mPreviousStackCount;
// Instantiates a new broadcast receiver for handling Fragment state
private FragmentDisplayer mFragmentDisplayer = new FragmentDisplayer();
// Sets a tag to use in logging
private static final String CLASS_TAG = "DisplayActivity";
/**
* Sets full screen mode on the device, by setting parameters in the current
* window and View
* @param fullscreen
*/
public void setFullScreen(boolean fullscreen) {
// If full screen is set, sets the fullscreen flag in the Window manager
getWindow().setFlags(
fullscreen ? WindowManager.LayoutParams.FLAG_FULLSCREEN : 0,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
// Sets the global fullscreen flag to the current setting
mFullScreen = fullscreen;
// If the platform version is Android 3.0 (Honeycomb) or above
if (Build.VERSION.SDK_INT >= 11) {
// Sets the View to be "low profile". Status and navigation bar icons will be dimmed
int flag = fullscreen ? View.SYSTEM_UI_FLAG_LOW_PROFILE : 0;
// If the platform version is Android 4.0 (ICS) or above
if (Build.VERSION.SDK_INT >= 14 && fullscreen) {
// Hides all of the navigation icons
flag |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
}
// Applies the settings to the screen View
mMainView.setSystemUiVisibility(flag);
// If the user requests a full-screen view, hides the Action Bar.
if ( fullscreen ) {
this.getActionBar().hide();
} else {
this.getActionBar().show();
}
}
}
/*
* A callback invoked when the task's back stack changes. This allows the app to
* move to the previous state of the Fragment being displayed.
*
*/
@Override
public void onBackStackChanged() {
// Gets the previous global stack count
int previousStackCount = mPreviousStackCount;
// Gets a FragmentManager instance
FragmentManager localFragmentManager = getSupportFragmentManager();
// Sets the current back stack count
int currentStackCount = localFragmentManager.getBackStackEntryCount();
// Re-sets the global stack count to be the current count
mPreviousStackCount = currentStackCount;
/*
* If the current stack count is less than the previous, something was popped off the stack
* probably because the user clicked Back.
*/
boolean popping = currentStackCount < previousStackCount;
Log.d(CLASS_TAG, "backstackchanged: popping = " + popping);
// When going backwards in the back stack, turns off full screen mode.
if (popping) {
setFullScreen(false);
}
}
/*
* This callback is invoked by the system when the Activity is being killed
* It saves the full screen status, so it can be restored when the Activity is restored
*
*/
@Override
protected void onSaveInstanceState(Bundle outState) {
outState.putBoolean(Constants.EXTENDED_FULLSCREEN, mFullScreen);
super.onSaveInstanceState(outState);
}
/*
* This callback is invoked when the Activity is first created. It sets up the Activity's
* window and initializes the Fragments associated with the Activity
*/
@Override
public void onCreate(Bundle stateBundle) {
// Sets fullscreen-related flags for the display
getWindow().setFlags(
WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
| WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR,
WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
| WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
// Calls the super method (required)
super.onCreate(stateBundle);
// Inflates the main View, which will be the host View for the fragments
mMainView = getLayoutInflater().inflate(R.layout.fragmenthost, null);
// Sets the content view for the Activity
setContentView(mMainView);
/*
* Creates an intent filter for DownloadStateReceiver that intercepts broadcast Intents
*/
// The filter's action is BROADCAST_ACTION
IntentFilter statusIntentFilter = new IntentFilter(
Constants.BROADCAST_ACTION);
// Sets the filter's category to DEFAULT
statusIntentFilter.addCategory(Intent.CATEGORY_DEFAULT);
// Instantiates a new DownloadStateReceiver
mDownloadStateReceiver = new DownloadStateReceiver();
// Registers the DownloadStateReceiver and its intent filters
LocalBroadcastManager.getInstance(this).registerReceiver(
mDownloadStateReceiver,
statusIntentFilter);
/*
* Creates intent filters for the FragmentDisplayer
*/
// One filter is for the action ACTION_VIEW_IMAGE
IntentFilter displayerIntentFilter = new IntentFilter(
Constants.ACTION_VIEW_IMAGE);
// Adds a data filter for the HTTP scheme
displayerIntentFilter.addDataScheme("http");
// Registers the receiver
LocalBroadcastManager.getInstance(this).registerReceiver(
mFragmentDisplayer,
displayerIntentFilter);
// Creates a second filter for ACTION_ZOOM_IMAGE
displayerIntentFilter = new IntentFilter(Constants.ACTION_ZOOM_IMAGE);
// Registers the receiver
LocalBroadcastManager.getInstance(this).registerReceiver(
mFragmentDisplayer,
displayerIntentFilter);
// Gets an instance of the support library FragmentManager
FragmentManager localFragmentManager = getSupportFragmentManager();
/*
* Detects if side-by-side display should be enabled. It's only available on xlarge and
* sw600dp devices (for example, tablets). The setting in res/values/ is "false", but this
* is overridden in values-xlarge and values-sw600dp.
*/
mSideBySide = getResources().getBoolean(R.bool.sideBySide);
/*
* Detects if hiding navigation controls should be enabled. On xlarge andsw600dp, it should
* be false, to avoid having the user enter an additional tap.
*/
mHideNavigation = getResources().getBoolean(R.bool.hideNavigation);
/*
* Adds the back stack change listener defined in this Activity as the listener for the
* FragmentManager. See the method onBackStackChanged().
*/
localFragmentManager.addOnBackStackChangedListener(this);
// If the incoming state of the Activity is null, sets the initial view to be thumbnails
if (null == stateBundle) {
// Starts a Fragment transaction to track the stack
FragmentTransaction localFragmentTransaction = localFragmentManager
.beginTransaction();
// Adds the PhotoThumbnailFragment to the host View
localFragmentTransaction.add(R.id.fragmentHost,
new PhotoThumbnailFragment(), Constants.THUMBNAIL_FRAGMENT_TAG);
// Commits this transaction to display the Fragment
localFragmentTransaction.commit();
// The incoming state of the Activity isn't null.
} else {
// Gets the previous state of the fullscreen indicator
mFullScreen = stateBundle.getBoolean(Constants.EXTENDED_FULLSCREEN);
// Sets the fullscreen flag to its previous state
setFullScreen(mFullScreen);
// Gets the previous backstack entry count.
mPreviousStackCount = localFragmentManager.getBackStackEntryCount();
}
}
/*
* This callback is invoked when the system is about to destroy the Activity.
*/
@Override
public void onDestroy() {
// If the DownloadStateReceiver still exists, unregister it and set it to null
if (mDownloadStateReceiver != null) {
LocalBroadcastManager.getInstance(this).unregisterReceiver(mDownloadStateReceiver);
mDownloadStateReceiver = null;
}
// Unregisters the FragmentDisplayer instance
LocalBroadcastManager.getInstance(this).unregisterReceiver(this.mFragmentDisplayer);
// Sets the main View to null
mMainView = null;
// Must always call the super method at the end.
super.onDestroy();
}
/*
* This callback is invoked when the system is stopping the Activity. It stops
* background threads.
*/
@Override
protected void onStop() {
// Cancel all the running threads managed by the PhotoManager
PhotoManager.cancelAll();
super.onStop();
}
/**
* This class uses the BroadcastReceiver framework to detect and handle status messages from
* the service that downloads URLs.
*/
private class DownloadStateReceiver extends BroadcastReceiver {
private DownloadStateReceiver() {
// prevents instantiation by other packages.
}
/**
*
* This method is called by the system when a broadcast Intent is matched by this class'
* intent filters
*
* @param context An Android context
* @param intent The incoming broadcast Intent
*/
@Override
public void onReceive(Context context, Intent intent) {
/*
* Gets the status from the Intent's extended data, and chooses the appropriate action
*/
switch (intent.getIntExtra(Constants.EXTENDED_DATA_STATUS,
Constants.STATE_ACTION_COMPLETE)) {
// Logs "started" state
case Constants.STATE_ACTION_STARTED:
if (Constants.LOGD) {
Log.d(CLASS_TAG, "State: STARTED");
}
break;
// Logs "connecting to network" state
case Constants.STATE_ACTION_CONNECTING:
if (Constants.LOGD) {
Log.d(CLASS_TAG, "State: CONNECTING");
}
break;
// Logs "parsing the RSS feed" state
case Constants.STATE_ACTION_PARSING:
if (Constants.LOGD) {
Log.d(CLASS_TAG, "State: PARSING");
}
break;
// Logs "Writing the parsed data to the content provider" state
case Constants.STATE_ACTION_WRITING:
if (Constants.LOGD) {
Log.d(CLASS_TAG, "State: WRITING");
}
break;
// Starts displaying data when the RSS download is complete
case Constants.STATE_ACTION_COMPLETE:
// Logs the status
if (Constants.LOGD) {
Log.d(CLASS_TAG, "State: COMPLETE");
}
// Finds the fragment that displays thumbnails
PhotoThumbnailFragment localThumbnailFragment =
(PhotoThumbnailFragment) getSupportFragmentManager().findFragmentByTag(
Constants.THUMBNAIL_FRAGMENT_TAG);
// If the thumbnail Fragment is hidden, don't change its display status
if ((localThumbnailFragment == null)
|| (!localThumbnailFragment.isVisible()))
return;
// Indicates that the thumbnail Fragment is visible
localThumbnailFragment.setLoaded(true);
break;
default:
break;
}
}
}
/**
* This class uses the broadcast receiver framework to detect incoming broadcast Intents
* and change the currently-visible fragment based on the Intent action.
* It adds or replaces Fragments as necessary, depending on how much screen real-estate is
* available.
*/
private class FragmentDisplayer extends BroadcastReceiver {
// Default null constructor
public FragmentDisplayer() {
// Calls the constructor for BroadcastReceiver
super();
}
/**
* Receives broadcast Intents for viewing or zooming pictures, and displays the
* appropriate Fragment.
*
* @param context The current Context of the callback
* @param intent The broadcast Intent that triggered the callback
*/
@Override
public void onReceive(Context context, Intent intent) {
// Declares a local FragmentManager instance
FragmentManager fragmentManager1;
// Declares a local instance of the Fragment that displays photos
PhotoFragment photoFragment;
// Stores a string representation of the URL in the incoming Intent
String urlString;
// If the incoming Intent is a request is to view an image
if (intent.getAction().equals(Constants.ACTION_VIEW_IMAGE)) {
// Gets an instance of the support library fragment manager
fragmentManager1 = getSupportFragmentManager();
// Gets a handle to the Fragment that displays photos
photoFragment =
(PhotoFragment) fragmentManager1.findFragmentByTag(
Constants.PHOTO_FRAGMENT_TAG
);
// Gets the URL of the picture to display
urlString = intent.getDataString();
// If the photo Fragment exists from a previous display
if (null != photoFragment) {
// If the incoming URL is not already being displayed
if (!urlString.equals(photoFragment.getURLString())) {
// Sets the Fragment to use the URL from the Intent for the photo
photoFragment.setPhoto(urlString);
// Loads the photo into the Fragment
photoFragment.loadPhoto();
}
// If the Fragment doesn't already exist
} else {
// Instantiates a new Fragment
photoFragment = new PhotoFragment();
// Sets the Fragment to use the URL from the Intent for the photo
photoFragment.setPhoto(urlString);
// Starts a new Fragment transaction
FragmentTransaction localFragmentTransaction2 =
fragmentManager1.beginTransaction();
// If the fragments are side-by-side, adds the photo Fragment to the display
if (mSideBySide) {
localFragmentTransaction2.add(
R.id.fragmentHost,
photoFragment,
Constants.PHOTO_FRAGMENT_TAG
);
/*
* If the Fragments are not side-by-side, replaces the current Fragment with
* the photo Fragment
*/
} else {
localFragmentTransaction2.replace(
R.id.fragmentHost,
photoFragment,
Constants.PHOTO_FRAGMENT_TAG);
}
// Don't remember the transaction (sets the Fragment backstack to null)
localFragmentTransaction2.addToBackStack(null);
// Commits the transaction
localFragmentTransaction2.commit();
}
// If not in side-by-side mode, sets "full screen", so that no controls are visible
if (!mSideBySide) setFullScreen(true);
/*
* If the incoming Intent is a request to zoom in on an existing image
* (Notice that zooming is only supported on large-screen devices)
*/
} else if (intent.getAction().equals(Constants.ACTION_ZOOM_IMAGE)) {
// If the Fragments are being displayed side-by-side
if (mSideBySide) {
// Gets another instance of the FragmentManager
FragmentManager localFragmentManager2 = getSupportFragmentManager();
// Gets a thumbnail Fragment instance
PhotoThumbnailFragment localThumbnailFragment =
(PhotoThumbnailFragment) localFragmentManager2.findFragmentByTag(
Constants.THUMBNAIL_FRAGMENT_TAG);
// If the instance exists from a previous display
if (null != localThumbnailFragment) {
// if the existing instance is visible
if (localThumbnailFragment.isVisible()) {
// Starts a fragment transaction
FragmentTransaction localFragmentTransaction2 =
localFragmentManager2.beginTransaction();
/*
* Hides the current thumbnail, clears the backstack, and commits the
* transaction
*/
localFragmentTransaction2.hide(localThumbnailFragment);
localFragmentTransaction2.addToBackStack(null);
localFragmentTransaction2.commit();
// If the existing instance is not visible, display it by going "Back"
} else {
// Pops the back stack to show the previous Fragment state
localFragmentManager2.popBackStack();
}
}
// Removes controls from the screen
setFullScreen(true);
}
}
}
}
}